﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using produccion.clases;
using produccion.AccesoDatos;
using System.Windows;
using System.Windows.Media.Imaging;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Windows.Input;
using System.Data;

namespace produccion.vistamodelo
{
    public class VMmantCategorias : ViewModelBase
    {
        #region fields

        private CLSMAEREF _referencia = new CLSMAEREF();
        private ProcesoProduccionRepositorio _repositorio=new ProcesoProduccionRepositorio();
        
        #endregion

        #region public intefaces

        //-----------------------------------------------------
        private string _strTituloVentana;
        public string strTituloVentana
        {
            get { return _strTituloVentana; }
            set { _strTituloVentana = value; base.OnPropertyChanged("strTituloVentana"); }
        }

        private VMbuscarReferencia _buscarReferencia;
        public VMbuscarReferencia buscarReferencia
        {
            get { return _buscarReferencia; }
            set { _buscarReferencia = value; base.OnPropertyChanged("buscarReferencia"); }
        }
        
        public string strCodRef 
        {
            get { return _referencia.CODREF_REF; }
            set 
            { 
                _referencia.CODREF_REF = value;
                consRef();
                consFoto();
                base.OnPropertyChanged("strCodRef");
            }
        }
        public string strNomRef
        {
            get { return _referencia.NOMREF_REF; }
            set { _referencia.NOMREF_REF = value; base.OnPropertyChanged("strNomRef"); }
        }
        
        private MDOgeneral.mensaje _msn = new MDOgeneral.mensaje();
        public MDOgeneral.mensaje msn 
        {
            get { return _msn; }
            set { _msn = value; base.OnPropertyChanged("msn"); }
        }

        private ObservableCollection<VMCategoria> _lisCategorias = new ObservableCollection<VMCategoria>();
        public ObservableCollection<VMCategoria> lisCategorias 
        { 
            get { return _lisCategorias; } 
            set { _lisCategorias = value; base.OnPropertyChanged("lisCategorias");  } 
        }

        private bool _errorLisCategorias = true;
        public bool errorLisCategorias 
        {
            get { return _errorLisCategorias;}
            set { _errorLisCategorias = value; base.OnPropertyChanged("errorLisCategorias"); }
        }

        private VMvisorFotoReferencia _visorFotoReferencia = new VMvisorFotoReferencia();
        public VMvisorFotoReferencia visorFotoReferencia
        {
            get { return _visorFotoReferencia; }
            set { _visorFotoReferencia = value; base.OnPropertyChanged("visorFotoReferencia"); }
        }

        RelayCommand _cmdGuardar;
        public ICommand cmdGuardar
        {
            get
            {

                if (_cmdGuardar == null)
                {
                    _cmdGuardar = new RelayCommand(r => Guardar());
                }
                return _cmdGuardar;
            }
        }

        RelayCommand _cmdSalir;
        public ICommand cmdSalir
        {
            get
            {
                if (_cmdSalir == null)
                {
                    _cmdSalir = new RelayCommand(Salir);
                }
                return _cmdSalir;
            }
        }

        private void Salir(object ventana)
        {
            try {

                ((Window)ventana).Close();
            
            }
            catch (Exception ex) { msn.texto = ex.Message; msn.tipo = false; }
        }

        private void Guardar()
        {
            try 
            {
                List<CLSCTGREF> categorias = (from cust in lisCategorias where cust.actualizar.Equals(true) select cust.getCategoria()).ToList();

                if (_repositorio.GuardarCategoriaProceso(categorias))
                {
                    msn.texto = "Los cambios fueron guardados exitosamente.";
                    msn.tipo=true;
                    consCategorias();
                    errorLisCategorias = true;
                }
                else 
                { 
                    msn.texto="Los cambios no pueden ser guardados.";
                    msn.tipo=false;
                }
            
            }
            catch (Exception ex) { msn.texto = ex.Message; msn.tipo = false; }
        }
        
        #endregion

        #region metodos

        //------------------------------------------------
        public VMmantCategorias()
        {
            buscarReferencia = new VMbuscarReferencia();
            buscarReferencia.TieneColor = false;
            buscarReferencia.PropertyChanged += OnBuscarReferenciaPropertyChanged;

            if (MDOgeneral.conexion == null || MDOgeneral.conexion.State == ConnectionState.Closed)
            {
                MDOgeneral.conectar();
            }
            strTituloVentana = "Mantenimiento de categorias - Usuario: " + MDOgeneral.usuario + " - [FRMmantCategorias]";
        }

        void OnBuscarReferenciaPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            try
            {
                if (e.PropertyName == "IsOpen")
                {
                    if (!buscarReferencia.IsOpen)
                    {
                        foreach (string x in buscarReferencia.listaProducto)
                        {
                            strCodRef = x;
                        }
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        RelayCommand _cmdBuscarReferencia;
        public ICommand cmdBuscarReferencia
        {
            get
            {
                if (_cmdBuscarReferencia == null)
                {
                    _cmdBuscarReferencia = new RelayCommand(r => buscar_referencia());
                }
                return _cmdBuscarReferencia;
            }
        }

        private void buscar_referencia()
        {
            try
            {
                buscarReferencia.TieneColor = false;
                buscarReferencia.IsOpen = true;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void consRef() 
        {
            try 
            {
                _referencia.ConsultarRefeoConc();
                base.OnPropertyChanged("strNomRef");
                if (_referencia.EXISTE) { consCategorias(); }
                else 
                {
                    lisCategorias.Clear();
                    if (strCodRef.Length >= 4)
                    {
                        buscar_referencia();
                    }
                }
            }
            catch (Exception ex) { msn.texto = ex.Message; msn.tipo = false; }
        }

        public void consFoto() 
        {
            try 
            {
                visorFotoReferencia.strCodigo = _referencia.CODREF_REF;
                visorFotoReferencia.strColor = _referencia.CODCOL_REF;
            }
            catch (Exception ex) { msn.texto = ex.Message; msn.tipo = false; }
        }   

        public void consCategorias()
        {
            try
            {
                lisCategorias = new ObservableCollection<VMCategoria>();
                List<CLSCTGREF> categorias=_repositorio.consCategoriaProcesos(_referencia);
                List<VMCategoria> all = (from cust in categorias select new VMCategoria(cust)).ToList();
                foreach (VMCategoria cust in all) cust.PropertyChanged += OnPropertyChanged;
                lisCategorias = new ObservableCollection<VMCategoria>(all);
            }
            catch (Exception ex) { msn.texto = ex.Message; msn.tipo = false; }
        }

        void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == "numValCat")
            {
                errorLisCategorias = ((from cust in lisCategorias where cust.IsValid.Equals(false) select cust.IsValid).ToList().Count()) > 0 ? true : false;
            }
        }

        #endregion

    }


    public class VMCategoria:ViewModelBase,IDataErrorInfo
    {

        #region fields
        private CLSCTGREF _categoria = new CLSCTGREF();
        #endregion

        #region constructor
        public VMCategoria(CLSCTGREF categoria)
        {
            try 
            {
                _categoria = categoria;     
            }
            catch (Exception ex) { throw ex; }
        }
        #endregion

        #region metodos

        public CLSCTGREF getCategoria()
        {
            return _categoria;
        }
        #endregion

        #region public interfaces

        public string strCodPrc 
        {
            get { return _categoria.proceso.CODPRC_PPR; }
            set { _categoria.proceso.CODPRC_PPR = value; base.OnPropertyChanged("strCodPrc"); }
        }
      
        public string strNomPrc
        {
            get { return _categoria.proceso.NOMPRC_PPR; }
            set { _categoria.proceso.NOMPRC_PPR = value; base.OnPropertyChanged("strNomPrc"); }
        }
        
        public double numValCat 
        {
            get { return _categoria.VALOR_CRF; }
            set 
            {
                if (_categoria.VALOR_CRF != value )
                    actualizar = true;
                _categoria.VALOR_CRF = value;
                base.OnPropertyChanged("numValCat");
            }
        }

        private bool _actualizar = false;
        public bool actualizar 
        {
            get { return _actualizar; }
            set { _actualizar = value; base.OnPropertyChanged("actualizar"); }
        }

        #endregion

        #region IDataErrorInfo Members

        string IDataErrorInfo.Error { get { return null; } }

        string IDataErrorInfo.this[string propertyName]
        {
            get { return this.GetValidationError(propertyName); }
        }

        #endregion

        #region Validation

        /// <summary>
        /// Returns true if this object has no validation errors.
        /// </summary>
        public bool IsValid
        {
            get
            {
                foreach (string property in ValidatedProperties)
                    if (GetValidationError(property) != null)
                        return false;

                return true;
            }
        }

        static readonly string[] ValidatedProperties = 
        { 
            "numValCat"
        };

        string GetValidationError(string propertyName)
        {
            if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                return null;

            string error = null;

            switch (propertyName)
            {
                case "numValCat":
                    error = this.ValidatenumValCat();
                    break;
                default:
                    Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                    break;
            }

            return error;
        }

        private string ValidatenumValCat()
        {
            if (numValCat < 0) 
            {
                return "El valor para la categoria no puede ser menor que 0.";
            }
            return null;
        }
        #endregion

    }
}
